import Bluetooth from "../../utils/bluetooth"
// pages/deviceDebuggingFun/deviceDebuggingFun.js
const app = getApp()
Page({

    /**
     * 页面的初始数据
     */
    data: {
        showConnect: false, // 判断是否连接成功
        characteristicId: '', // 蓝牙设备的写入特征值
        vibrationMode: [{ // 震动方式
            type: 'shockType',
            name: '长震动',
            value: 0
        }, {
            type: 'shockType',
            name: '短震动',
            value: 1
        }],
        vibrationModeIndex: 1,
        delayTime: [{ // 延迟震动
            type: 'delayShockTime',
            name: '无延迟',
            value: 0
        }, {
            type: 'delayShockTime',
            name: '2s',
            value: 2
        }, {
            type: 'delayShockTime',
            name: '3s',
            value: 3
        }, {
            type: 'delayShockTime',
            name: '5s',
            value: 5
        }, {
            type: 'delayShockTime',
            name: '10s',
            value: 10
        }, {
            type: 'delayShockTime',
            name: '20s',
            value: 20
        }, {
            type: 'delayShockTime',
            name: '30s',
            value: 30
        }, {
            type: 'delayShockTime',
            name: '60s',
            value: 60
        }],
        delayTimeIndex: 1,
        angle: [{ // 提醒角度
            type: 'slope',
            name: '5°',
            value: 5
        }, {
            type: 'slope',
            name: '10°',
            value: 10
        }, {
            type: 'slope',
            name: '15°',
            value: 15
        }, {
            type: 'slope',
            name: '20°',
            value: 20
        }, {
            type: 'slope',
            name: '25°',
            value: 25
        }],
        angleIndex: 1,
        vibrationTimeReminder: [{ // 自动开启震动时间提醒
            type: 'autoStartShockWarn',
            name: '不开启',
            value: 0
        }, {
            type: 'autoStartShockWarn',
            name: '15分钟',
            value: 15
        }, {
            type: 'autoStartShockWarn',
            name: '30分钟',
            value: 30
        }, {
            type: 'autoStartShockWarn',
            name: '1小时',
            value: 60
        }, {
            type: 'autoStartShockWarn',
            name: '2小时',
            value: 120
        }],
        vibrationTimeReminderIndex: 0,
        sedentaryTime: [{ // 久坐时间提醒
            type: 'sedentaryReminderTime',
            name: '1小时',
            value: 1
        }, {
            type: 'sedentaryReminderTime',
            name: '2小时',
            value: 2
        }, {
            type: 'sedentaryReminderTime',
            name: '3小时',
            value: 3
        }, {
            type: 'sedentaryReminderTime',
            name: '4小时',
            value: 4
        }, {
            type: 'sedentaryReminderTime',
            name: '5小时',
            value: 5
        }],
        sedentaryTimeIndex: 0,
        isSedentaryRemIndex: 1, // switch 久坐提醒开关
        arrayX: [],    // x 轴
        direction: '00',     // 设备倾斜方向值
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        const {
            deviceId
        } = options
        console.log('设备Id', deviceId)
        if (deviceId) {
            this.connectDeviceBle(deviceId)
        }
    },

    // 与设备进行连接
    connectDeviceBle(deviceId) {
        let _loadingCount = 1,
            title = '连接中...'
        wx.showLoading({
            title,
        })
        Bluetooth.createBLEConnection(deviceId).then((res) => {
            console.warn('连接成功')
            if (_loadingCount == 1) {
                _loadingCount = 0
                wx.hideLoading({}).then((res) => {
                    this.getDeviceServices(deviceId)
                })
            }
        }).catch((err) => {
            console.log('连接设备失败--原因', err)
        })
    },

    // 获取设备服务值(主服务) services
    getDeviceServices(deviceId) {
        let _loadingCount = 1,
            title = '获取服务中...',
            serviceId = ''
        wx.showLoading({
            title,
        })
        Bluetooth.getBLEDeviceServices(deviceId).then((res) => {
            console.warn('获取服务值成功')
            console.warn('设备所有服务值', res.services)
            res.services.forEach((item) => {
                if (item.uuid.includes('FF00') && item.isPrimary) { // FF00--矫姿设备主服务
                    serviceId = item.uuid
                    if (_loadingCount == 1) {
                        _loadingCount = 0
                        wx.hideLoading({}).then((res) => {
                            this.getDeviceCharacteristics(deviceId, serviceId)
                        })
                    }
                }
            })
        }).catch((err) => {
            console.log('获取设备服务失败--原因', err)
        })
    },

    // 获取设备所有特征值--characteristics(读/写特征值)
    getDeviceCharacteristics(deviceId, serviceId) {
        let _loadingCount = 1,
            title = '读取特征值...',
            characteristicId = ''
        wx.showLoading({
            title,
        })
        Bluetooth.getBLEDeviceCharacteristics(deviceId, serviceId).then((res) => {
            console.warn('获取到设备主服务下的所有特征值', res.characteristics)
            res.characteristics.forEach((item) => {
                characteristicId = item.uuid
                if (_loadingCount == 1) {
                    _loadingCount = 0
                    wx.hideLoading({}).then((res) => {
                        console.log('设备连接成功')
                        this.setData({
                            showConnect: true
                        })
                    })
                }
                if (item.properties.notify) { // 读--特征值
                    console.log('读-特征值', characteristicId)
                    this.notifyDeviceCharacteristicValueChange(deviceId, serviceId, characteristicId)
                }
                if (item.properties.write) { // 写--特征值
                    console.log('写-特征值', characteristicId)
                    this.setData({
                        deviceId,
                        serviceId,
                        characteristicId
                    })
                }
            })
        }).catch((err) => {
            console.log('读取设备特征值(读/写)失败--原因', err)
        })
    },

    // 监听设备广播出来的数据变化时触发
    notifyDeviceCharacteristicValueChange(deviceId, serviceId, characteristicId) {
        console.log('进入到监听蓝牙广播数据notify方法里')
        Bluetooth.notifyBLECharacteristicValueChange(deviceId, serviceId, characteristicId).then((res) => {
            wx.onBLECharacteristicValueChange((res) => {    // 监听蓝牙低功耗设备的特征值变化事件
                let value = Bluetooth.ab2hex(res.value)
                console.log('蓝牙设备广播出来的数据--解析后', value)
                this.dataHandle(value)
            })
        }).catch((err) => {
            console.log('监听到蓝牙广播出来的数据失败--原因', err)
        })
    },
    // 监听到的设备数据处理
    async dataHandle(value) {
        let type = value.slice(4, 6) // 类型
        let fx, x, y, z // 设备倾斜方向(驼背|左倾|右倾|左前倾|右前倾)
        let surplusElectric // 设备剩余电量
        let fieldName = 'direction'
        // let arrayX = this.data.arrayX
        if (type === '05') { // 05 标志位,是设备变化时广播出来的数据(数据包含三维坐标点,设备当前状态,设备电量)
            fx = value.slice(18, 20)
            x = value.slice(6, 10)
            y = value.slice(10, 14)
            z = value.slice(14, 18)
            surplusElectric = value.slice(20, 22)
            let originalX = await this.handleCoordinateValue(x)
            let originalY = await this.handleCoordinateValue(y)
            let originalZ = await this.handleCoordinateValue(z)
            
            console.log('设备剩余电量', surplusElectric, parseInt(surplusElectric, 16))
            // console.log('类型(十进制)', type, 'x轴坐标', originalX, 'y轴坐标', originalY, 'z轴坐标', originalZ)
            this.updateData(fieldName, fx)
            // if(fx === '00') {
            //     console.log('正常接收到的数据--电量', value, surplusElectric)
            // } else if(fx === '03') {
            //     console.log('前倾驼背接收到的数据--电量', value, surplusElectric)
            // } else if(fx === '02') {
            //     console.log('左倾接收到的数据--电量', value, surplusElectric)
            // } else if(fx === '01') {
            //     console.log('右倾接收到的数据--电量', value, surplusElectric)
            // } else if(fx === '05') {
            //     console.log('左前倾接收到的数据--电量', value, surplusElectric)
            // } else if(fx === '06') {
            //     console.log('右前倾接收到的数据--电量', value, surplusElectric)
            // }
        } else if (type === '02') {  // 向设备发送修改设备相关功能参数之后设备返回的数据
            console.log('向设备发送设置相关的参数(震动方式|延迟震动|提醒角度...)-成功', value)
        }
    },

    // 处理接收到的蓝牙广播出来的数据(正负)
    handleCoordinateValue(value) {
        let original
        if(parseInt((Number('0x' + value) & 0x8000).toString(16)) === 8000) {  // x值--负值
            original = 0-(parseInt((~Number('0x' + value) & 0xffff).toString(10)) + 1)   // 先转成十进制整数,取反加一
        } else {   // x值--正值
            original = parseInt(Number('0x' + value).toString(10))
        }
        return original
    },

    // 设备设置项配置相关--底部弹起选择器,所有的设置项配置,包含switch
    async setVibrationMode(e) {
        let { currentTarget: { dataset: { type } }, detail: { value } } = e
        if (type === 'vibrationModeIndex') {   // 震动方式
            console.log('震动方式')
            this.updateData(type, value)
        } else if (type === 'delayTimeIndex') {   // 延迟震动
            console.log('延迟震动')
            this.updateData(type, value)
        } else if (type === 'angleIndex') {   // 提醒角度
            console.log('提醒角度')
            this.updateData(type, value)
        } else if (type === 'vibrationTimeReminderIndex') {   // 定时自启震动提醒
            console.log('自动开启震动提醒')
            this.updateData(type, value)
        } else if(type === 'isSedentaryRemIndex') {    // switch是否开启提醒时间
            console.log('是否开启提醒时间')
            this.updateData(type, value)
        } else if (type === 'sedentaryTimeIndex') {    // 久坐提醒时间
            console.log('久坐提醒时间')
            this.updateData(type, value)
        }
        this.writeDeviceInstructions()
    },

    // 向设备写入指令
    writeDeviceInstructions() {
        wx.showLoading({
          title: '配置中...',
        })
        let { deviceId, serviceId, characteristicId } = this.data
        let { vibrationModeIndex, delayTime, delayTimeIndex, angle, angleIndex, vibrationTimeReminder, vibrationTimeReminderIndex, isSedentaryRemIndex, sedentaryTime, sedentaryTimeIndex } = this.data  // 依次是:震动方式、延迟震动、提醒角度、定时自启震动、是否开启提醒开关和久坐提醒时间
        console.log('设置相关参数', vibrationModeIndex, delayTimeIndex, angleIndex, vibrationTimeReminderIndex, isSedentaryRemIndex, sedentaryTimeIndex + 1)
        // console.log('参数--倾斜角度和延时震动', setupValue.slope, setupValue.delayShockTime)
        let hexStrValue = `4A5A02${(vibrationModeIndex).toString(16).padStart(2, '0')}${(delayTime[delayTimeIndex].value).toString(16).padStart(2, '0')}${(angle[angleIndex].value).toString(16).padStart(2, '0')}${(vibrationTimeReminder[vibrationTimeReminderIndex].value).toString(16).padStart(2, '0')}${(0).toString(16).padStart(2, '0')}${(isSedentaryRemIndex).toString(16).padStart(2, '0')}${(sedentaryTime[sedentaryTimeIndex].value * 60).toString(16).padStart(2, '0')}5342`
        console.log('准备发送的十六进制字符串', hexStrValue)
        let value = Bluetooth.hexStringToArrayBuffer(hexStrValue)
        console.log('arrayBuf长度', value)
        Bluetooth.writeBLECharacteristicValue(deviceId, serviceId, characteristicId, value).then((res) => {
            wx.hideLoading({
              success: (res) => {
                  wx.showToast({
                    title: '配置成功',
                    icon: 'success',
                    duration: 2000,
                    mask: true
                  })
              },
            })
            console.log('写入数据成功', res)
        }).catch((err) => {
            console.error('写入数据失败', err)
        })
    },

    // 解绑设备的事件回调
    unboundChange() {
        wx.showModal({
            title: '提示',
            content: '确定解绑设备',
            confirmText: '解绑',
            confirmColor: '#f00',
            success: (res) => {
                if (res.confirm) {
                    this.setData({
                        showConnect: false
                    })
                    Bluetooth.closeBluetoothAdapter().then((res) => {
                        console.log('断开设备连接并释放系统资源成功')
                        wx.navigateBack()
                    }).catch((err) => {
                        console.error('断开设备连接并释放系统资源失败', err)
                    })
                }
            }
        })

    },

    // 封装更新值的方法
    updateData(fieldName, value) {
        this.setData({
            [fieldName]: Number(value)
        })
    },

    // 维盛平台提供的ota升级方法----固件升级功能
    updateFirmware1(e) {
        let { currentTarget: { dataset: { deviceId } } } = e
        console.log('蓝牙设备ID', deviceId)
        const fs = wx.getFileSystemManager()
        wx.downloadFile({
            url: 'https://tjl-health.oss-cn-shenzhen.aliyuncs.com/20220608101016mybjssvl.bin',  // https://tjl-health.oss-cn-shenzhen.aliyuncs.com/20220608101016mybjssvl.bin
            success: (res) => {
                fs.readFile({
                    filePath: res.tempFilePath,
                    success: (res) => {
                        console.log('读取的文件数据', res.data)
                        let loadReturnValue = Ota.load(res.data) // 加载固件,成功返回undefined,失败返回错误提示
                        console.log('加载固件文件返回值', loadReturnValue)
                        if (loadReturnValue !== undefined) {
                            wx.showToast({
                                title: '固件错误',
                            })
                            return
                        } else {
                            console.log('固件加载成功')
                            this.getFirmwareInformation(deviceId)
                        }
                    }
                })
            }
        })
    },
    // 获取固件相关信息
    getFirmwareInformation(deviceId) {
        Ota.otaBeaconStart()  // 广播启动
        wx.showLoading({
          title: '请稍等...',
        })
        console.warn('准备链接的设备Id', deviceId)
        Ota.deviceConnect({   // 连接设备,前提条件是固件加载成功
            deviceId,
            connected: (res) => {   // 成功
                console.log('设备连接成功获取设备版本信息', res)

                Ota.startUpdate({   // 启动固件更新
                    rebootMode: 2,   // 更新后重启到指定模式(0正常模式;1升级模式;2裂变模式;3强制裂变模式)
                    progress: (res) => {
                        console.log('固件更新情况.已更新的固件大小--固件大小', res.txSize, res.frimSize)
                        if(res.txSize >= res.frimSize) {
                            wx.hideLoading({}).then((res) => {
                                wx.showToast({
                                    title: '更新成功!',
                                    icon: 'none'
                                })
                            })
                        }
                    },
                    fail: (err) => {
                        console.log('固件更新失败--失败原因', err)
                        // Ota.deviceConnect({
                        //     deviceId,
                        //     connected: (res) => {
                        //         console.log('固件升级过程中断开之后,重连成功', res)
                        //     }
                        // })
                    }
                })

                // Ota.rebootToMode({
                //     mode: 1,
                //     success: (res) => {
                //         console.log('设备切换到指定模式成功', res)
                //     },
                //     fail: (err) => {
                //         console.log('重启设备到指定的模式失败', err)
                //     }
                // })

            },
            fail: (err) => {   // 失败
                console.log('设备连接失败', err)
            },
            disconnected: () => {
                console.log('设备已断开')
            }
        })
        
        // let frimwareInfo = Ota.getFrimwareInfo()  // 获取固件信息
        // console.log('获取固件信息', frimwareInfo)
    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
        this.connectionStateChange()
    },
    // 监听蓝牙低功耗连接状态的改变事件
    connectionStateChange() {
        wx.onBLEConnectionStateChange((res) => {
            if(res.connected === false) {   // 蓝牙断开
                console.log('蓝牙连接状态断开事件,蓝牙id--状态', res.deviceId, res.connected)
                let deviceId = res.deviceId
                this.setData({
                    showConnect: false
                })
                wx.showModal({
                    title: '提示',
                    content: '长按设备按钮开启蓝牙,是否重连?',
                    confirmText: '是',
                    cancelText: '否',
                    success: (res) => {
                        if(res.confirm) {  // 点击'是'
                            this.connectDeviceBle(deviceId)
                        }
                        if(res.cancel) {   // 点击'否'
                            wx.navigateBack({})
                        }
                    }
                })
            }
        })
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

})